// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
#nullable disable
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Host;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.Test.Utilities
{
    public abstract class TestHostProject<TDocument> : AbstractTestHostProject
        where TDocument : TestHostDocument
    {
        private readonly HostLanguageServices _languageServices;
 
        private readonly ProjectId _id;
        private readonly string _name;
        private readonly IEnumerable<AnalyzerReference> _analyzerReferences;
        private readonly string _assemblyName;
        private readonly string _defaultNamespace;
 
        public IEnumerable<TDocument> Documents;
        public IEnumerable<TDocument> AdditionalDocuments;
        public IEnumerable<TDocument> AnalyzerConfigDocuments;
        public IEnumerable<ProjectReference> ProjectReferences;
 
        public override string Name
        {
            get
            {
                return _name;
            }
        }
 
        public IEnumerable<MetadataReference> MetadataReferences { get; }
 
        public IEnumerable<AnalyzerReference> AnalyzerReferences
        {
            get
            {
                return _analyzerReferences;
            }
        }
 
        public CompilationOptions CompilationOptions { get; }
 
        public ParseOptions ParseOptions { get; }
 
        public override ProjectId Id
        {
            get
            {
                return _id;
            }
        }
 
        public bool IsSubmission { get; }
 
        public override string AssemblyName
        {
            get
            {
                return _assemblyName;
            }
        }
 
        public Type HostObjectType { get; }
 
        public VersionStamp Version { get; }
 
        public string FilePath { get; private set; }
 
        internal void OnProjectFilePathChanged(string filePath)
            => FilePath = filePath;
 
        public string DefaultNamespace
        {
            get { return _defaultNamespace; }
        }
 
        protected TestHostProject(
            HostLanguageServices languageServices,
            CompilationOptions compilationOptions,
            ParseOptions parseOptions,
            string assemblyName,
            string projectName,
            IList<MetadataReference> references,
            IList<TDocument> documents,
            IList<TDocument> additionalDocuments = null,
            IList<TDocument> analyzerConfigDocuments = null,
            Type hostObjectType = null,
            bool isSubmission = false,
            string filePath = null,
            IList<AnalyzerReference> analyzerReferences = null,
            string defaultNamespace = null)
        {
            _assemblyName = assemblyName;
            _name = projectName;
            _id = ProjectId.CreateNewId(debugName: this.AssemblyName);
            _languageServices = languageServices;
            CompilationOptions = compilationOptions;
            ParseOptions = parseOptions;
            MetadataReferences = references;
            _analyzerReferences = analyzerReferences ?? SpecializedCollections.EmptyEnumerable<AnalyzerReference>();
            this.Documents = documents;
            this.AdditionalDocuments = additionalDocuments ?? SpecializedCollections.EmptyEnumerable<TDocument>();
            this.AnalyzerConfigDocuments = analyzerConfigDocuments ?? SpecializedCollections.EmptyEnumerable<TDocument>();
            ProjectReferences = SpecializedCollections.EmptyEnumerable<ProjectReference>();
            IsSubmission = isSubmission;
            HostObjectType = hostObjectType;
            Version = VersionStamp.Create();
            FilePath = filePath;
            _defaultNamespace = defaultNamespace;
        }
 
        protected TestHostProject(
            HostWorkspaceServices hostServices,
            string name = null,
            string language = null,
            CompilationOptions compilationOptions = null,
            ParseOptions parseOptions = null,
            IEnumerable<TDocument> documents = null,
            IEnumerable<TDocument> additionalDocuments = null,
            IEnumerable<TDocument> analyzerConfigDocuments = null,
            IEnumerable<TestHostProject<TDocument>> projectReferences = null,
            IEnumerable<MetadataReference> metadataReferences = null,
            IEnumerable<AnalyzerReference> analyzerReferences = null,
            string assemblyName = null,
            string defaultNamespace = null)
        {
            _name = name ?? "TestProject";
 
            _id = ProjectId.CreateNewId(debugName: this.Name);
 
            language = language ?? LanguageNames.CSharp;
            _languageServices = hostServices.GetLanguageServices(language);
 
            CompilationOptions = compilationOptions ?? this.LanguageServiceProvider.GetService<ICompilationFactoryService>().GetDefaultCompilationOptions();
            ParseOptions = parseOptions ?? this.LanguageServiceProvider.GetService<ISyntaxTreeFactoryService>().GetDefaultParseOptions();
            this.Documents = documents ?? SpecializedCollections.EmptyEnumerable<TDocument>();
            this.AdditionalDocuments = additionalDocuments ?? SpecializedCollections.EmptyEnumerable<TDocument>();
            this.AnalyzerConfigDocuments = analyzerConfigDocuments ?? SpecializedCollections.EmptyEnumerable<TDocument>();
            ProjectReferences = projectReferences != null ? projectReferences.Select(p => new ProjectReference(p.Id)) : SpecializedCollections.EmptyEnumerable<ProjectReference>();
            MetadataReferences = metadataReferences ?? new MetadataReference[] { NetFramework.mscorlib };
            _analyzerReferences = analyzerReferences ?? SpecializedCollections.EmptyEnumerable<AnalyzerReference>();
            _assemblyName = assemblyName ?? "TestProject";
            Version = VersionStamp.Create();
            _defaultNamespace = defaultNamespace;
 
            if (documents != null)
            {
                foreach (var doc in documents)
                {
                    doc.SetProject(this);
                }
            }
 
            if (additionalDocuments != null)
            {
                foreach (var doc in additionalDocuments)
                {
                    doc.SetProject(this);
                }
            }
 
            if (analyzerConfigDocuments != null)
            {
                foreach (var doc in analyzerConfigDocuments)
                {
                    doc.SetProject(this);
                }
            }
        }
 
        internal void SetSolution()
        {
            // set up back pointer to this project.
            if (this.Documents != null)
            {
                foreach (var doc in this.Documents)
                {
                    doc.SetProject(this);
                }
 
                foreach (var doc in this.AdditionalDocuments)
                {
                    doc.SetProject(this);
                }
 
                foreach (var doc in this.AnalyzerConfigDocuments)
                {
                    doc.SetProject(this);
                }
            }
        }
 
        internal void AddDocument(TDocument document)
        {
            this.Documents = this.Documents.Concat(new TDocument[] { document });
            document.SetProject(this);
        }
 
        internal void RemoveDocument(TDocument document)
            => this.Documents = this.Documents.Where(d => d != document);
 
        internal void AddAdditionalDocument(TDocument document)
        {
            this.AdditionalDocuments = this.AdditionalDocuments.Concat(new TDocument[] { document });
            document.SetProject(this);
        }
 
        internal void RemoveAdditionalDocument(TDocument document)
            => this.AdditionalDocuments = this.AdditionalDocuments.Where(d => d != document);
 
        internal void AddAnalyzerConfigDocument(TDocument document)
        {
            this.AnalyzerConfigDocuments = this.AnalyzerConfigDocuments.Concat(new TDocument[] { document });
            document.SetProject(this);
        }
 
        internal void RemoveAnalyzerConfigDocument(TDocument document)
            => this.AnalyzerConfigDocuments = this.AnalyzerConfigDocuments.Where(d => d != document);
 
        public override string Language
        {
            get
            {
                return _languageServices.Language;
            }
        }
 
        public override HostLanguageServices LanguageServiceProvider
        {
            get
            {
                return _languageServices;
            }
        }
 
        public ProjectInfo ToProjectInfo()
        {
            var info = ProjectInfo.Create(
                new ProjectInfo.ProjectAttributes(
                    Id,
                    Version,
                    name: Name,
                    assemblyName: AssemblyName,
                    language: Language,
                    compilationOutputInfo: default,
                    checksumAlgorithm: Text.SourceHashAlgorithms.Default,
                    defaultNamespace: DefaultNamespace,
                    filePath: FilePath,
                    outputFilePath: GetTestOutputFilePath(FilePath, "bin"),
                    isSubmission: IsSubmission),
                CompilationOptions,
                ParseOptions,
                documents: Documents.Where(d => !d.IsSourceGenerated).Select(d => d.ToDocumentInfo()),
                ProjectReferences,
                MetadataReferences,
                AnalyzerReferences,
                additionalDocuments: AdditionalDocuments.Select(d => d.ToDocumentInfo()),
                analyzerConfigDocuments: AnalyzerConfigDocuments.Select(d => d.ToDocumentInfo()),
                HostObjectType);
 
            if (CompilationOptions != null)
            {
                info = info.WithCompilationOutputInfo(new CompilationOutputInfo(
                    assemblyPath: GetTestOutputFilePath(FilePath, "obj"),
                    generatedFilesOutputDirectory: null));
            }
 
            return info;
        }
 
        // It is identical with the internal extension method 'GetDefaultExtension' defined in OutputKind.cs.
        // However, we could not apply for InternalVisibleToTest due to other parts of this assembly
        // complaining about CS0507: "cannot change access modifiers when overriding 'access' inherited member".
        private static string GetDefaultExtension(OutputKind kind)
        {
            switch (kind)
            {
                case OutputKind.ConsoleApplication:
                case OutputKind.WindowsApplication:
                case OutputKind.WindowsRuntimeApplication:
                    return ".exe";
 
                case OutputKind.DynamicallyLinkedLibrary:
                    return ".dll";
 
                case OutputKind.NetModule:
                    return ".netmodule";
 
                case OutputKind.WindowsRuntimeMetadata:
                    return ".winmdobj";
 
                default:
                    return ".dll";
            }
        }
 
        private string GetTestOutputFilePath(string projectFilePath, string subdir)
        {
            return CompilationOptions == null ? "" : Path.Combine(GetTestOutputDirectory(projectFilePath), subdir, AssemblyName + GetDefaultExtension(CompilationOptions.OutputKind));
        }
    }
}